package tcp

import (
	"context"
	"fmt"
	"io"
	"log"
	"net"
	"sync"

	"internal-net-bridge-server/internal/tunnel/core"

	"github.com/quic-go/quic-go"
)

// ========================================
// TCP协议转发器实现
// 实现 core.QUICForwarder 的TCP部分
// ========================================

// Forwarder TCP协议转发器
type Forwarder struct {
	quicServer QUICServerInterface
}

// QUICServerInterface QUIC服务器接口（避免循环依赖）
// 简化接口设计，直接返回quic.Conn
type QUICServerInterface interface {
	// GetQUICConnection 获取QUIC连接
	GetQUICConnection(tunnelID string, protocolType core.ProtocolType) (*quic.Conn, error)
	// GetContext 获取上下文
	GetContext() context.Context
}

// NewForwarder 创建TCP转发器
func NewForwarder(quicServer QUICServerInterface) *Forwarder {
	return &Forwarder{
		quicServer: quicServer,
	}
}

// ForwardHTTPRequest HTTP转发（TCP协议不实现）
func (f *Forwarder) ForwardHTTPRequest(tunnelID, requestID string, httpReq []byte) ([]byte, error) {
	return nil, fmt.Errorf("TCP转发器不支持HTTP请求转发")
}

// ForwardHTTPRequestStream HTTP流式转发（TCP协议不实现）
func (f *Forwarder) ForwardHTTPRequestStream(tunnelID, requestID string, httpReq []byte, responseWriter net.Conn) error {
	return fmt.Errorf("TCP转发器不支持HTTP流式转发")
}

// ForwardTCPConnection 转发TCP连接（实现core.QUICForwarder接口）
func (f *Forwarder) ForwardTCPConnection(tunnelID, requestID string, clientConn net.Conn) error {
	log.Printf("🔌 [TCP转发器] 转发连接: TunnelID=%s, RequestID=%s",
		tunnelID[:8]+"...", requestID[:8]+"...")

	// 获取QUIC连接
	quicConn, err := f.quicServer.GetQUICConnection(tunnelID, core.ProtocolTCP)
	if err != nil {
		return fmt.Errorf("获取QUIC连接失败: %w", err)
	}

	// 打开Stream
	ctx := f.quicServer.GetContext()
	stream, err := quicConn.OpenStreamSync(ctx)
	if err != nil {
		return fmt.Errorf("打开Stream失败: %w", err)
	}
	defer stream.Close()

	// 构建TCP请求消息
	// 注意：这里需要使用正确的消息构建函数
	// 由于避免循环依赖，我们使用简化的方式
	reqMsg := buildTCPRequestMessage(tunnelID, requestID)
	if _, err := stream.Write(reqMsg); err != nil {
		return fmt.Errorf("写入请求消息失败: %w", err)
	}

	// 双向数据转发
	var wg sync.WaitGroup
	errChan := make(chan error, 2)

	// 从客户端TCP连接读取 → 写入QUIC Stream
	wg.Add(1)
	go func() {
		defer wg.Done()
		_, err := io.Copy(stream, clientConn)
		if err != nil && err != io.EOF {
			errChan <- fmt.Errorf("复制到Stream失败: %w", err)
		}
		stream.Close() // 关闭写入端
	}()

	// 从QUIC Stream读取 → 写入客户端TCP连接
	wg.Add(1)
	go func() {
		defer wg.Done()
		_, err := io.Copy(clientConn, stream)
		if err != nil && err != io.EOF {
			errChan <- fmt.Errorf("从Stream复制失败: %w", err)
		}
	}()

	wg.Wait()
	close(errChan)

	// 检查错误
	for err := range errChan {
		if err != nil {
			log.Printf("❌ [TCP转发器] %v", err)
			return err
		}
	}

	log.Printf("✅ [TCP转发器] 连接转发完成: RequestID=%s", requestID[:8]+"...")
	return nil
}

// buildTCPRequestMessage 构建TCP请求消息（简化版本）
// 实际应该使用协议包的NewRequestMessage
func buildTCPRequestMessage(tunnelID, requestID string) []byte {
	// 这里需要构建完整的QUIC协议消息
	// 为了避免循环依赖，这里使用简化实现
	// 实际生产环境应该使用完整的协议编码

	// TODO: 实现完整的消息编码
	// 目前返回一个占位符
	msg := fmt.Sprintf("TCP_REQUEST|%s|%s\n", tunnelID, requestID)
	return []byte(msg)
}
